package com.xuzhen.interceptor.two;

/** 
 *  模拟webwork的拦截器
 */  
import java.util.ArrayList;
import java.util.Iterator;
  
public class ActionInvocation {  
	 public boolean executed = false;  
	  //这个intercepters必须是成员变量
	 protected Iterator<Intercepter> intercepters;  
	  
	 public String resultCode;  
	  
	 public String invoke() throws Exception {  
		  if (executed) {  
			  throw new IllegalStateException("Action has already executed");  
		  }  
		  
		  if (intercepters.hasNext()) {  
			   // 因为intercepters是类成员变量，所以递归执行到这里的时候，会执行一个Intercepter的intercept方法，知道都迭代完毕
			   Intercepter intercepter = (Intercepter) intercepters.next();  
			
			   //递归  
			   // here is recure point ,programm run to here  
			   // then save the state into the stack ,and jump to the top of the method run again  
			   // and so and so util the condition to else branch  
			   resultCode = intercepter.intercept(this);  
			     
		  } else {  
			  resultCode = invokeActionOnly();  
		  }  
		  
		  if (!executed) {  
		     
			   System.out.println("now it is time to run the action, and this method should not run again!!");  
			   executed = true;  
		  }  
		  return resultCode;  
	 }  
	  
	 private String invokeActionOnly() {  
		  System.out.println("run invokeActionOnly() ");  
		  // invoke和intercept的递归的时候返回都将是这个值，所以这个返回值能够保存到最后，  
		  // 只是在两个方法之间被多次地传递  
		  return "here is action return value,it's the result;";  
	 }  
	  
	 public ActionInvocation(){  
		  ArrayList<Intercepter> ay=new ArrayList<Intercepter>(); 
		  ay.add(new Intercepter(1));  
		  ay.add(new Intercepter(2));  
		  ay.add(new Intercepter(3));  
		  intercepters=ay.iterator();  
	    
	 }  
	 public static void main(String[] args) {  
		  ActionInvocation actionInvocation =new ActionInvocation();  
		  try {  
			  System.out.println(actionInvocation.invoke());  
		  } catch (Exception e) {    
			  e.printStackTrace();  
		  }   
	}  
}  
